import api from './axios'

/**
 * 用户管理相关API
 * 注意: 角色相关的API已移至 src/services/role.js
 */

// Admin用户保护常量
const ADMIN_USERNAME = 'admin';
const ADMIN_USER_ID = 1; // 假设admin用户ID为1
const PROTECTED_ERROR = '系统保护: 管理员账号不允许被修改';

// 检查是否为受保护的admin用户
const isProtectedAdminUser = (userId) => {
  return userId === ADMIN_USER_ID;
}

// 检查数组中是否包含admin用户
const containsAdminUser = (userIds) => {
  return userIds.includes(ADMIN_USER_ID);
}

// 从数组中过滤掉admin用户
const filterOutAdminUser = (userIds) => {
  return userIds.filter(id => id !== ADMIN_USER_ID);
}

// 操作符映射
const OPERATOR_MAP = {
  equals: 'equals',
  contains: 'contains',
  startsWith: 'startsWith',
  endsWith: 'endsWith',
  greaterThan: 'greaterThan',
  lessThan: 'lessThan',
  between: 'between'
};

export const userService = {
  // 获取用户列表
  getUsers: async ({ page = 1, pageSize = 10, filters = {} } = {}) => {
    try {
      const params = new URLSearchParams({
        page,
        page_size: pageSize,
        ...filters
      })
      
      const response = await api.get(`/users/search/?${params.toString()}`)
      
      // 添加调试日志
      console.log('Normal search API response:', response.data);
      
      // 处理跟高级搜索一样的数据结构
      // 首先检查是否有status和data字段（顶层结构）
      if (response.data?.status === 200 && response.data?.data) {
        // 如果匹配示例中的格式
        return {
          data: response.data.data.results || [],
          total: response.data.data.count || 0,
          next: response.data.data.next,
          previous: response.data.data.previous
        };
      } 
      // 检查是否直接返回了results（没有status封装）
      else if (response.data?.results) {
        return {
          data: response.data.results || [],
          total: response.data.count || 0,
          next: response.data.next,
          previous: response.data.previous
        };
      }
      // 如果返回的是数组
      else if (Array.isArray(response.data)) {
        return {
          data: response.data,
          total: response.data.length,
          next: null,
          previous: null
        };
      }
      // 兜底处理
      else {
        console.warn('Unexpected API response format:', response.data);
        return {
          data: [],
          total: 0,
          next: null,
          previous: null
        };
      }
    } catch (error) {
      console.error('Failed to get users:', error)
      throw error
    }
  },
  
  // 高级搜索用户
  advancedSearch: async ({ 
    page = 1, 
    pageSize = 10, 
    conditions = [], 
    logic = 'AND',
    sort = { field: 'created_at', direction: 'desc' }
  } = {}) => {
    try {
      // 构建高级搜索请求体
      const requestData = {
        conditions,
        logic,
        sort,
        page,
        page_size: pageSize
      };
      
      const response = await api.post('/users/advanced_search/', requestData);
      
      // 添加调试日志以查看实际返回结构
      console.log('Advanced search API response:', response.data);
      
      // 根据实际返回的数据结构灵活处理
      // 首先检查是否有status和data字段（顶层结构）
      if (response.data?.status === 200 && response.data?.data) {
        // 如果匹配示例中的格式
        return {
          data: response.data.data.results || [],
          total: response.data.data.count || 0,
          next: response.data.data.next,
          previous: response.data.data.previous
        };
      } 
      // 检查是否直接返回了results（没有status封装）
      else if (response.data?.results) {
        return {
          data: response.data.results || [],
          total: response.data.count || 0,
          next: response.data.next,
          previous: response.data.previous
        };
      }
      // 如果返回的是数组
      else if (Array.isArray(response.data)) {
        return {
          data: response.data,
          total: response.data.length,
          next: null,
          previous: null
        };
      }
      // 兜底处理
      else {
        console.warn('Unexpected API response format:', response.data);
        return {
          data: [],
          total: 0,
          next: null,
          previous: null
        };
      }
    } catch (error) {
      console.error('Failed to perform advanced search:', error);
      throw error;
    }
  },
  
  // 获取单个用户
  getUser: async (id) => {
    try {
      const response = await api.get(`/users/${id}/`)
      return response.data
    } catch (error) {
      console.error(`Failed to get user ${id}:`, error)
      throw error
    }
  },
  
  // 添加用户
  addUser: async (userData) => {
    try {
      // 确保数据格式符合API要求
      const requestData = {
        username: userData.username,
        password: userData.password,
        real_name: userData.real_name,
        email: userData.email,
        phone: userData.phone,
        // 如果提供了角色IDs，也包含它们
        ...(userData.roles?.length > 0 ? { roles: userData.roles } : {})
      }
      
      const response = await api.post('/users/', requestData)
      return response.data
    } catch (error) {
      console.error('Failed to add user:', error)
      // 如果是409冲突(用户名已存在)，抛出特定错误
      if (error.response?.status === 409) {
        throw new Error('该用户名已被使用')
      }
      throw error
    }
  },
  
  // 更新用户
  updateUser: async (id, userData) => {
    try {
      // 保护admin用户不被修改
      if (isProtectedAdminUser(id)) {
        throw new Error(PROTECTED_ERROR);
      }
      
      // 创建不包含password的数据对象，除非明确提供了新密码
      const requestData = {
        username: userData.username,
        real_name: userData.real_name,
        email: userData.email,
        phone: userData.phone,
        status: userData.status
      }
      
      // 如果提供了密码且非空，添加到请求中
      if (userData.password) {
        requestData.password = userData.password
      }
      
      // 如果提供了角色IDs，也包含它们
      if (userData.roles?.length > 0) {
        requestData.roles = userData.roles
      }
      
      const response = await api.put(`/users/${id}/`, requestData)
      return response.data
    } catch (error) {
      console.error(`Failed to update user ${id}:`, error)
      if (error.message === PROTECTED_ERROR) {
        throw error;
      }
      if (error.response?.status === 409) {
        throw new Error('该用户名已被使用')
      }
      throw error
    }
  },
  
  // 更新用户（部分字段）
  updateUserPartial: async (id, userData) => {
    try {
      // 保护admin用户不被修改
      if (isProtectedAdminUser(id)) {
        throw new Error(PROTECTED_ERROR);
      }
      
      // 只更新提供的字段
      const response = await api.patch(`/users/${id}/`, userData)
      return response.data
    } catch (error) {
      console.error(`Failed to update user ${id}:`, error)
      if (error.message === PROTECTED_ERROR) {
        throw error;
      }
      if (error.response?.status === 409) {
        throw new Error('该用户名已被使用')
      }
      throw error
    }
  },
  
  // 删除用户
  deleteUsers: async (userIds) => {
    try {
      // 检查是否包含admin用户
      if (containsAdminUser(userIds)) {
        // 如果只有admin一个用户，直接拒绝操作
        if (userIds.length === 1) {
          throw new Error(PROTECTED_ERROR);
        }
        
        // 从删除列表中过滤掉admin用户
        console.warn('尝试删除admin用户，已自动跳过');
        userIds = filterOutAdminUser(userIds);
      }
      
      // 串行处理删除请求，以便更好地处理错误
      const results = [];
      const errors = [];
      
      for (const id of userIds) {
        try {
          await api.delete(`/users/${id}/`);
          results.push(id);
        } catch (err) {
          // 记录错误信息
          const errorMessage = err.response?.data?.message || 
                               err.response?.data?.errors?.detail || 
                               `删除用户(ID: ${id})失败`;
          
          errors.push({
            id,
            error: errorMessage,
            status: err.response?.status
          });
          
          console.error(`Failed to delete user ${id}:`, err);
        }
      }
      
      // 如果有错误，抛出包含详细信息的错误
      if (errors.length > 0) {
        // 如果所有删除都失败
        if (errors.length === userIds.length) {
          throw new Error(
            errors.length === 1 
              ? `删除用户失败: ${errors[0].error}`
              : `删除全部 ${errors.length} 个用户失败`
          );
        }
        
        // 如果部分删除成功
        throw new Error(
          `成功删除 ${results.length} 个用户, 但有 ${errors.length} 个删除失败` +
          (errors.length === 1 ? `: ${errors[0].error}` : '')
        );
      }
      
      return results;
    } catch (error) {
      // 直接抛出外部错误（如网络问题）或上面处理过的错误
      throw error;
    }
  },
  
  // 修改用户状态
  updateStatus: async (userIds, status) => {
    try {
      // 检查是否包含admin用户
      if (containsAdminUser(userIds)) {
        // 如果只有admin一个用户，直接拒绝操作
        if (userIds.length === 1) {
          throw new Error(PROTECTED_ERROR);
        }
        
        // 从操作列表中过滤掉admin用户
        console.warn('尝试修改admin用户状态，已自动跳过');
        userIds = filterOutAdminUser(userIds);
      }
      
      // 如果过滤后没有用户需要操作，直接返回
      if (userIds.length === 0) {
        return true;
      }
      
      const promises = userIds.map(id => 
        api.patch(`/users/${id}/`, { status })
      )
      await Promise.all(promises)
      return true
    } catch (error) {
      console.error('Failed to update user status:', error)
      throw error
    }
  },
  
  // 重置密码
  resetPassword: async (userId) => {
    try {
      // 保护admin用户密码不被重置
      if (isProtectedAdminUser(userId)) {
        throw new Error(PROTECTED_ERROR);
      }
      
      const response = await api.post(`/users/${userId}/reset-password/`)
      return response.data
    } catch (error) {
      console.error(`Failed to reset password for user ${userId}:`, error)
      throw error
    }
  },
  
  // 分配角色
  assignRoles: async (userIds, roleIds) => {
    try {
      // 检查是否包含admin用户
      if (containsAdminUser(userIds)) {
        // 如果只有admin一个用户，直接拒绝操作
        if (userIds.length === 1) {
          throw new Error(PROTECTED_ERROR);
        }
        
        // 从操作列表中过滤掉admin用户
        console.warn('尝试修改admin用户角色，已自动跳过');
        userIds = filterOutAdminUser(userIds);
      }
      
      // 如果过滤后没有用户需要操作，直接返回
      if (userIds.length === 0) {
        return [];
      }
      
      // 串行处理角色分配请求，以便更好地处理错误
      const results = [];
      const errors = [];
      
      for (const userId of userIds) {
        try {
          const response = await api.post(`/users/${userId}/assign_roles/`, { role_ids: roleIds })
          results.push({
            userId,
            message: response.data?.detail || '角色分配成功'
          });
        } catch (err) {
          // 记录错误信息
          const errorMessage = err.response?.data?.message || 
                               err.response?.data?.errors?.detail || 
                               `为用户(ID: ${userId})分配角色失败`;
          
          errors.push({
            userId,
            error: errorMessage,
            status: err.response?.status
          });
          
          console.error(`Failed to assign roles to user ${userId}:`, err);
        }
      }
      
      // 如果有错误，抛出包含详细信息的错误
      if (errors.length > 0) {
        // 如果所有分配都失败
        if (errors.length === userIds.length) {
          throw new Error(
            errors.length === 1 
              ? `角色分配失败: ${errors[0].error}`
              : `为全部 ${errors.length} 个用户分配角色失败`
          );
        }
        
        // 如果部分分配成功
        throw new Error(
          `成功为 ${results.length} 个用户分配角色, 但有 ${errors.length} 个分配失败` +
          (errors.length === 1 ? `: ${errors[0].error}` : '')
        );
      }
      
      return results;
    } catch (error) {
      // 直接抛出外部错误（如网络问题）或上面处理过的错误
      throw error;
    }
  },
  
  // 导出用户数据
  exportUsers: async () => {
    try {
      const response = await api.get('/users/export/', { responseType: 'blob' })
      const url = window.URL.createObjectURL(new Blob([response.data]))
      const link = document.createElement('a')
      link.href = url
      link.setAttribute('download', `users_export_${new Date().toISOString().split('T')[0]}.xlsx`)
      document.body.appendChild(link)
      link.click()
      document.body.removeChild(link)
      return true
    } catch (error) {
      console.error('Failed to export users:', error)
      throw error
    }
  }
}